package com.chamber.business.mqtt.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.chamber.business.domain.MachineInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * MQTT消息处理器
 * 用于处理不同主题的MQTT消息
 */
@Slf4j
@Service
public class MqttMessageHandler {

    /**
     * 处理MQTT消息
     *
     * @param topic   消息主题
     * @param message 消息内容
     */
    public void handleMessage(String topic, String message) {
        log.info("处理MQTT消息，主题: {}, 内容: {}", topic, message);

        try {
            // 根据不同主题处理消息
            if (topic.startsWith("cmd/request")) {
                // 处理设备请求消息
                handleRequestMessage(message);
            } else if (topic.startsWith("cmd/response")) {
                // 处理设备响应消息
                handleResponseMessage(message);
            } else if (topic.startsWith("cmd/ack")) {
                // 处理设备确认消息
                handleAckMessage(message);
            } else {
                log.warn("未知主题消息: {}", topic);
            }
        } catch (Exception e) {
            log.error("处理MQTT消息异常", e);
        }
    }

    /**
     * 处理设备请求消息
     *
     * @param message 消息内容
     */
    private void handleRequestMessage(String message) {
        try {
            JSONObject jsonObject = JSON.parseObject(message);
            Long machineNum = jsonObject.getLong("machineNum");
            String requestType = jsonObject.getString("requestType");

            log.info("收到设备请求，设备编号: {}, 请求类型: {}", machineNum, requestType);

            // 根据请求类型处理不同请求
            switch (requestType) {
                case "status":
                    // 处理状态上报请求
                    handleStatusReport(jsonObject);
                    break;
                case "error":
                    // 处理错误上报请求
                    handleErrorReport(jsonObject);
                    break;
                default:
                    log.warn("未知请求类型: {}", requestType);
            }
        } catch (Exception e) {
            log.error("处理设备请求消息异常", e);
        }
    }

    /**
     * 处理设备响应消息
     *
     * @param message 消息内容
     */
    private void handleResponseMessage(String message) {
        try {
            JSONObject jsonObject = JSON.parseObject(message);
            Long machineNum = jsonObject.getLong("machineNum");
            String action = jsonObject.getString("action");
            Boolean success = jsonObject.getBoolean("success");

            log.info("收到设备响应，设备编号: {}, 操作: {}, 结果: {}", machineNum, action, success);

            // 根据操作类型和结果更新设备状态
            if (success) {
                // 操作成功，更新设备状态
                updateMachineStatus(jsonObject);
            } else {
                // 操作失败，记录错误
                String errorMsg = jsonObject.getString("errorMsg");
                log.error("设备操作失败，设备编号: {}, 操作: {}, 错误: {}", machineNum, action, errorMsg);
            }
        } catch (Exception e) {
            log.error("处理设备响应消息异常", e);
        }
    }

    /**
     * 处理设备确认消息
     *
     * @param message 消息内容
     */
    private void handleAckMessage(String message) {
        try {
            JSONObject jsonObject = JSON.parseObject(message);
            Long machineNum = jsonObject.getLong("machineNum");
            String commandId = jsonObject.getString("commandId");

            log.info("收到设备确认消息，设备编号: {}, 命令ID: {}", machineNum, commandId);

            // 更新命令状态为已确认
            // TODO: 实现命令状态更新逻辑
        } catch (Exception e) {
            log.error("处理设备确认消息异常", e);
        }
    }

    /**
     * 处理设备状态上报
     *
     * @param jsonObject 消息JSON对象
     */
    private void handleStatusReport(JSONObject jsonObject) {
        try {
            Long machineNum = jsonObject.getLong("machineNum");
            JSONObject statusData = jsonObject.getJSONObject("data");

            // 构建设备状态信息
            MachineInfo machineInfo = new MachineInfo();
            machineInfo.setMachineNum(machineNum);
            machineInfo.setOxygenConcentration(statusData.getLong("oxygenConcentration"));
            machineInfo.setPressure(statusData.getLong("pressure"));
            machineInfo.setAirQuality(statusData.getShort("airQuality"));
            machineInfo.setVolume(statusData.getLong("volume"));
            machineInfo.setIlluminationIntensity(statusData.getLong("illuminationIntensity"));
            machineInfo.setOxygenTherapy(statusData.getBoolean("oxygenTherapy"));

            log.info("更新设备状态信息: {}", machineInfo);

            // TODO: 保存设备状态信息到数据库或缓存
        } catch (Exception e) {
            log.error("处理设备状态上报异常", e);
        }
    }

    /**
     * 处理设备错误上报
     *
     * @param jsonObject 消息JSON对象
     */
    private void handleErrorReport(JSONObject jsonObject) {
        try {
            Long machineNum = jsonObject.getLong("machineNum");
            String errorCode = jsonObject.getString("errorCode");
            String errorMsg = jsonObject.getString("errorMsg");

            log.error("设备错误上报，设备编号: {}, 错误代码: {}, 错误信息: {}", machineNum, errorCode, errorMsg);

            // TODO: 记录设备错误信息到数据库
        } catch (Exception e) {
            log.error("处理设备错误上报异常", e);
        }
    }

    /**
     * 更新设备状态
     *
     * @param jsonObject 消息JSON对象
     */
    private void updateMachineStatus(JSONObject jsonObject) {
        try {
            Long machineNum = jsonObject.getLong("machineNum");
            String action = jsonObject.getString("action");

            // 根据不同操作类型更新设备状态
            switch (action) {
                case "power":
                    // 更新设备开关状态
                    Integer status = jsonObject.getInteger("value");
                    log.info("更新设备开关状态，设备编号: {}, 状态: {}", machineNum, status);
                    // TODO: 更新设备状态到数据库
                    break;
                case "oxygen":
                    // 更新氧气浓度
                    Long oxygenValue = jsonObject.getLong("value");
                    log.info("更新设备氧气浓度，设备编号: {}, 浓度: {}", machineNum, oxygenValue);
                    // TODO: 更新设备氧气浓度到数据库
                    break;
                case "pressure":
                    // 更新气压
                    Long pressureValue = jsonObject.getLong("value");
                    log.info("更新设备气压，设备编号: {}, 气压: {}", machineNum, pressureValue);
                    // TODO: 更新设备气压到数据库
                    break;
                case "volume":
                    // 更新音量
                    Long volumeValue = jsonObject.getLong("value");
                    log.info("更新设备音量，设备编号: {}, 音量: {}", machineNum, volumeValue);
                    // TODO: 更新设备音量到数据库
                    break;
                case "light":
                    // 更新光照强度
                    Long lightValue = jsonObject.getLong("value");
                    log.info("更新设备光照强度，设备编号: {}, 强度: {}", machineNum, lightValue);
                    // TODO: 更新设备光照强度到数据库
                    break;
                case "therapy":
                    // 更新氧疗功能状态
                    Boolean therapyEnabled = jsonObject.getBoolean("value");
                    log.info("更新设备氧疗功能状态，设备编号: {}, 状态: {}", machineNum, therapyEnabled);
                    // TODO: 更新设备氧疗功能状态到数据库
                    break;
                default:
                    log.warn("未知操作类型: {}", action);
            }
        } catch (Exception e) {
            log.error("更新设备状态异常", e);
        }
    }
}